Mac Easy 2010 May/Mac Life Ubuntu.iso/casper/filesystem.squashfs/usr/lib/gedit-2/plugins/snippets/SubstitutionParser.pyc

Python Compiled Bytecode | 2009-04-20 | 7.0 KB | 216 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.6)

import re

class ParseError(Exception):

    def __str__(self):
        return 'Parse error, resume next'



class Modifiers:

    def _first_char(s):
        if not s != '' or s[0]:
            pass
        first = ''
        if not len(s) > 1 or s[1:]:
            pass
        rest = ''
        return (first, rest)


    def upper_first(s):
        (first, rest) = Modifiers._first_char(s)
        return '%s%s' % (first.upper(), rest)


    def upper(s):
        return s.upper()


    def lower_first(s):
        (first, rest) = Modifiers._first_char(s)
        return '%s%s' % (first.lower(), rest)


    def lower(s):
        return s.lower()


    def title(s):
        return s.title()

    upper_first = staticmethod(upper_first)
    upper = staticmethod(upper)
    lower_first = staticmethod(lower_first)
    lower = staticmethod(lower)
    title = staticmethod(title)
    _first_char = staticmethod(_first_char)


class SubstitutionParser:
    REG_ID = '[0-9]+'
    REG_NAME = '[a-zA-Z_]+'
    REG_MOD = '[a-zA-Z]+'
    REG_ESCAPE = '\\\\|\\(\\?|,|\\)'

    def __init__(self, pattern, groups = { }, modifiers = { }):
        self.pattern = pattern
        self.groups = groups
        self.REG_GROUP = '(?:(%s)|<(%s|%s)(?:,(%s))?>)' % (self.REG_ID, self.REG_ID, self.REG_NAME, self.REG_MOD)
        self.modifiers = {
            'u': Modifiers.upper_first,
            'U': Modifiers.upper,
            'l': Modifiers.lower_first,
            'L': Modifiers.lower,
            't': Modifiers.title }
        for k, v in modifiers.items():
            self.modifiers[k] = v



    def parse(self):
        (result, tokens) = self._parse(self.pattern, None)
        return result


    def _parse(self, tokens, terminator):
        result = ''
        while tokens != '':
            if self._peek(tokens) == '' or self._peek(tokens) == terminator:
                tokens = self._remains(tokens)
                break


            try:
                (res, tokens) = self._expr(tokens, terminator)
            except ParseError:
                (res, tokens) = self._text(tokens)

            result += res
        return (result, tokens)


    def _peek(self, tokens, num = 0):
        if num < len(tokens):
            pass
        return tokens[num]


    def _token(self, tokens):
        if tokens == '':
            return ('', '')
        if not len(tokens) > 1 or tokens[1:]:
            pass
        return (tokens[0], '')


    def _remains(self, tokens, num = 1):
        if not num < len(tokens) or tokens[num:]:
            pass
        return ''


    def _expr(self, tokens, terminator):
        if tokens == '':
            return ''

        try:
            return {
                '\\': self._escape,
                '(': self._condition }[self._peek(tokens)](tokens, terminator)
        except KeyError:
            tokens == ''
            tokens == ''
            raise ParseError
        except:
            tokens == ''



    def _text(self, tokens):
        return self._token(tokens)


    def _substitute(self, group, modifiers = ''):
        if not self.groups.has_key(group) or self.groups[group]:
            pass
        result = ''
        for modifier in modifiers:
            if self.modifiers.has_key(modifier):
                result = self.modifiers[modifier](result)
                continue

        return result


    def _match_group(self, tokens):
        match = re.match('\\\\%s' % self.REG_GROUP, tokens)
        if not match:
            return (None, tokens)
        if not match.group(1):
            pass
        if not match.group(3):
            pass
        return (self._substitute(match.group(2), ''), tokens[match.end():])


    def _escape(self, tokens, terminator):
        (result, tokens) = self._match_group(tokens)
        if result != None:
            return (result, tokens)
        s = self.REG_GROUP
        if terminator:
            s += '|%s' % re.escape(terminator)

        match = re.match('\\\\(\\\\%s|%s)' % (s, self.REG_ESCAPE), tokens)
        if not match:
            raise ParseError
        match
        return (match.group(1), tokens[match.end():])


    def _condition_value(self, tokens):
        match = re.match('\\\\?%s\\s*' % self.REG_GROUP, tokens)
        if not match:
            return (None, tokens)
        groups = match.groups()
        if not groups[0]:
            pass
        name = groups[1]
        if self.groups.has_key(name):
            pass
        return (self.groups[name] != None, tokens[match.end():])


    def _condition(self, tokens, terminator):
        if self._peek(tokens, 1) != '?':
            raise ParseError
        self._peek(tokens, 1) != '?'
        tokens = self._remains(tokens, 2)
        (condition, tokens) = self._condition_value(tokens)
        if condition == None or self._peek(tokens) != ',':
            raise ParseError
        self._peek(tokens) != ','
        (truepart, tokens) = self._parse(self._remains(tokens), ',')
        if truepart == None:
            raise ParseError
        truepart == None
        (falsepart, tokens) = self._parse(tokens, ')')
        if falsepart == None:
            raise ParseError
        falsepart == None
        if condition:
            return (truepart, tokens)
        return (falsepart, tokens)


    def escape_substitution(substitution):
        return re.sub('(%s|%s)' % (self.REG_GROUP, self.REG_ESCAPE), '\\\\\\1', substitution)

    escapesubstitution = staticmethod(escape_substitution)